home *** CD-ROM | disk | FTP | other *** search
/ Night Owl 9 / Night Owl CD-ROM (NOPV9) (Night Owl Publisher) (1993).ISO / 001a / seyon213.tz / seyon213 / seyon / MultiList.c < prev    next >
C/C++ Source or Header  |  1993-02-25  |  59KB  |  1,779 lines
  1. /****************************************************************************
  2.  
  3.     MultiList.c
  4.  
  5.     This file contains the implementation of the Picasso List
  6.     widget.  Its functionality is intended to be similar to
  7.     The Athena List widget, with some extra features added.
  8.  
  9.     This code is loosely based on the Athena List source which
  10.     is why the MIT copyright notice appears below.
  11.  
  12.     December 31, 1990, Brian Totty
  13.  
  14.  ****************************************************************************/
  15.  
  16. /*
  17.  * Copyright 1989 Massachusetts Institute of Technology
  18.  *
  19.  * Permission to use, copy, modify, distribute, and sell this software and its
  20.  * documentation for any purpose is hereby granted without fee, provided that
  21.  * the above copyright notice appear in all copies and that both that
  22.  * copyright notice and this permission notice appear in supporting
  23.  * documentation, and that the name of M.I.T. not be used in advertising or
  24.  * publicity pertaining to distribution of the software without specific,
  25.  * written prior permission.  M.I.T. makes no representations about the
  26.  * suitability of this software for any purpose.  It is provided "as is"
  27.  * without express or implied warranty.
  28.  *
  29.  * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
  30.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T.
  31.  * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  32.  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  33.  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  34.  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  35.  *
  36.  * Original Athena Author:  Chris D. Peterson, MIT X Consortium
  37.  */
  38.  
  39. #include <stdio.h>
  40. #ifndef NOSTDHDRS
  41. #include <stdlib.h>
  42. #endif
  43. #include <ctype.h>
  44.  
  45. #include <X11/IntrinsicP.h>
  46. #include <X11/StringDefs.h>
  47.  
  48. #include "MultiListP.h"
  49.  
  50. /*===========================================================================*
  51.  
  52.           D E C L A R A T I O N S    A N D    D E F I N I T I O N S
  53.  
  54.  *===========================================================================*/
  55.  
  56. Pixmap          XmuCreateStippledPixmap();
  57. extern void     XawInitializeWidgetSet();
  58.  
  59. #define    SUPERCLASS    &(simpleClassRec)
  60.  
  61. #define    FontAscent(f)    ((f)->max_bounds.ascent)
  62. #define    FontDescent(f)    ((f)->max_bounds.descent)
  63. #define    FontH(f)    (FontAscent(f) + FontDescent(f) + 2)
  64. #define    FontW(f,s)    (XTextWidth(f,s,strlen(s)) + 1)
  65. #define    FontMaxCharW(f)    ((f)->max_bounds.rbearing-(f)->min_bounds.lbearing+1)
  66.  
  67. #ifndef abs
  68. #define abs(a)            ((a) < 0 ? -(a) : (a))
  69. #endif
  70.  
  71. #define max(a,b)        ((a) > (b) ? (a) : (b))
  72. #define min(a,b)        ((a) < (b) ? (a) : (b))
  73. #define XtStrlen(s)        ((s) ? strlen(s) : 0)
  74.  
  75. #define    TypeAlloc(t,n)        (t *)malloc(sizeof(t) * n)
  76. #define    StrCopy(s)        strcpy(TypeAlloc(char,strlen(s)+1),s)
  77. #define    StrCopyRetLength(s,lp)    strcpy(TypeAlloc(char,(*lp=(strlen(s)+1))),s)
  78.  
  79. #define CoreFieldOffset(f)    XtOffset(Widget,core.f)
  80. #define    SimpleFieldOffset(f)    XtOffset(XfwfMultiListWidget,simple.f)
  81. #define MultiListFieldOffset(f)    XtOffset(XfwfMultiListWidget,multiList.f)
  82.  
  83. /*===========================================================================*
  84.  
  85.         I N T E R N A L    P R O C E D U R E    D E C L A R A T I O N S
  86.  
  87.  *===========================================================================*/
  88.  
  89. #if (!NeedFunctionPrototypes)
  90.  
  91. static void     Initialize();
  92. static void     Redisplay();
  93. static XtGeometryResult PreferredGeometry();
  94. static void     Resize();
  95. static Boolean  SetValues();
  96.  
  97. static void     DestroyOldData();
  98. static void     InitializeNewData();
  99. static void     CreateNewGCs();
  100.  
  101. static void     RecalcCoords();
  102. static void     NegotiateSizeChange();
  103. static Boolean  Layout();
  104.  
  105. static void     RedrawAll();
  106. static void     RedrawItem();
  107. static void     RedrawRowColumn();
  108.  
  109. static void     PixelToRowColumn();
  110. static void     RowColumnToPixels();
  111. static Boolean  RowColumnToItem();
  112. static Boolean  ItemToRowColumn();
  113.  
  114. static void     Set();
  115. static void     Unset();
  116. static void     Toggle();
  117. static void     Open();
  118. static void     OpenMany();
  119. static void     Notify();
  120.  
  121. #else
  122.  
  123. static void     Initialize(Widget request, Widget new);
  124. static void     Redisplay(XfwfMultiListWidget mlw,
  125.               XEvent * event, Region rectangle_union);
  126. static XtGeometryResult PreferredGeometry(XfwfMultiListWidget mlw,
  127.                       XtWidgetGeometry * parent_idea,
  128.                       XtWidgetGeometry * our_idea);
  129. static void     Resize(XfwfMultiListWidget mlw);
  130. static Boolean  SetValues(XfwfMultiListWidget cpl,
  131.               XfwfMultiListWidget rpl,
  132.               XfwfMultiListWidget npl);
  133. static void     DestroyOldData(XfwfMultiListWidget mlw);
  134. static void     InitializeNewData(XfwfMultiListWidget mlw);
  135. static void     CreateNewGCs(XfwfMultiListWidget mlw);
  136. static void     RecalcCoords(XfwfMultiListWidget mlw,
  137.                  int width_changeable,
  138.                  int height_changeable);
  139. static void     NegotiateSizeChange(XfwfMultiListWidget mlw,
  140.                     int width, int height);
  141. static Boolean  Layout(XfwfMultiListWidget mlw,
  142.                int w_changeable, int h_changeable,
  143.                Dimension * w_ptr, Dimension * h_ptr);
  144. static void     RedrawAll(XfwfMultiListWidget mlw);
  145. static void     RedrawItem(XfwfMultiListWidget mlw, int item_index);
  146. static void     RedrawRowColumn(XfwfMultiListWidget mlw,
  147.                 int row, int column);
  148. static void     PixelToRowColumn(XfwfMultiListWidget mlw,
  149.                    int x, int y, int *row_ptr, int *column_ptr);
  150. static void     RowColumnToPixels(XfwfMultiListWidget mlw,
  151.                   int row, int col, int *x_ptr, int *y_ptr,
  152.                   int *w_ptr, int *h_ptr);
  153. static Boolean  RowColumnToItem(XfwfMultiListWidget mlw,
  154.                 int row, int column, int *item_ptr);
  155. static Boolean  ItemToRowColumn(XfwfMultiListWidget mlw,
  156.                  int item_index, int *row_ptr, int *column_ptr);
  157. static void     Set(XfwfMultiListWidget mlw, XEvent * event,
  158.             String * params, Cardinal * num_params);
  159. static void     Unset(XfwfMultiListWidget mlw, XEvent * event,
  160.               String * params, Cardinal * num_params);
  161. static void     Toggle(XfwfMultiListWidget mlw, XEvent * event,
  162.                String * params, Cardinal * num_params);
  163. static void     Open(XfwfMultiListWidget mlw, XEvent * event,
  164.              String * params, Cardinal * num_params);
  165. static void     OpenMany(XfwfMultiListWidget mlw, XEvent * event,
  166.              String * params, Cardinal * num_params);
  167. static void     Notify(XfwfMultiListWidget mlw, XEvent * event,
  168.                String * params, Cardinal * num_params);
  169. #endif
  170.  
  171. /*===========================================================================*
  172.  
  173.               R E S O U R C E    I N I T I A L I Z A T I O N
  174.  
  175.  *===========================================================================*/
  176.  
  177. static XtResource resources[] =
  178. {
  179.   {XtNwidth, XtCWidth, XtRDimension, sizeof(Dimension),
  180.    CoreFieldOffset(width), XtRString, "0"},
  181.   {XtNheight, XtCHeight, XtRDimension, sizeof(Dimension),
  182.    CoreFieldOffset(height), XtRString, "0"},
  183.   {XtNbackground, XtCBackground, XtRPixel, sizeof(Pixel),
  184.    CoreFieldOffset(background_pixel), XtRString, "XtDefaultBackground"},
  185.  
  186.   {XtNcursor, XtCCursor, XtRCursor, sizeof(Cursor),
  187.    SimpleFieldOffset(cursor), XtRString, "left_ptr"},
  188.  
  189.   {XtNforeground, XtCForeground, XtRPixel, sizeof(Pixel),
  190.    MultiListFieldOffset(foreground), XtRString, "XtDefaultForeground"},
  191.   {XtNhighlightForeground, XtCHForeground, XtRPixel, sizeof(Pixel),
  192.    MultiListFieldOffset(highlight_fg), XtRString, "XtDefaultBackground"},
  193.   {XtNhighlightBackground, XtCHBackground, XtRPixel, sizeof(Pixel),
  194.    MultiListFieldOffset(highlight_bg), XtRString, "XtDefaultForeground"},
  195.   {XtNcolumnSpacing, XtCSpacing, XtRDimension, sizeof(Dimension),
  196.    MultiListFieldOffset(column_space), XtRImmediate, (caddr_t) 8},
  197.   {XtNrowSpacing, XtCSpacing, XtRDimension, sizeof(Dimension),
  198.    MultiListFieldOffset(row_space), XtRImmediate, (caddr_t) 0},
  199.   {XtNdefaultColumns, XtCColumns, XtRInt, sizeof(int),
  200.    MultiListFieldOffset(default_cols), XtRImmediate, (caddr_t) 1},
  201.   {XtNforceColumns, XtCColumns, XtRBoolean, sizeof(Boolean),
  202.    MultiListFieldOffset(force_cols), XtRString, (caddr_t) "False"},
  203.   {XtNpasteBuffer, XtCBoolean, XtRBoolean, sizeof(Boolean),
  204.    MultiListFieldOffset(paste), XtRString, (caddr_t) "False"},
  205.   {XtNverticalList, XtCBoolean, XtRBoolean, sizeof(Boolean),
  206.    MultiListFieldOffset(row_major), XtRString, (caddr_t) "False"},
  207.   {XtNlongest, XtCLongest, XtRInt, sizeof(int),
  208.    MultiListFieldOffset(longest), XtRImmediate, (caddr_t) 0},
  209.   {XtNnumberStrings, XtCNumberStrings, XtRInt, sizeof(int),
  210.    MultiListFieldOffset(nitems), XtRImmediate, (caddr_t) 0},
  211.   {XtNfont, XtCFont, XtRFontStruct, sizeof(XFontStruct *),
  212.    MultiListFieldOffset(font), XtRString, "XtDefaultFont"},
  213.   {XtNlist, XtCList, XtRPointer, sizeof(char **),
  214.    MultiListFieldOffset(list), XtRString, NULL},
  215.   {XtNsensitiveArray, XtCList, XtRPointer, sizeof(Boolean *),
  216.    MultiListFieldOffset(sensitive_array), XtRString, NULL},
  217.   {XtNcallback, XtCCallback, XtRCallback, sizeof(caddr_t),
  218.    MultiListFieldOffset(callback), XtRCallback, NULL},
  219.   {XtNmaxSelectable, XtCValue, XtRInt, sizeof(int),
  220.    MultiListFieldOffset(max_selectable), XtRImmediate, (caddr_t) 1},
  221.   {XtNnotifyHighlights, XtCBoolean, XtRBoolean, sizeof(Boolean),
  222.    MultiListFieldOffset(notify_highlights), XtRString, "True"},
  223.   {XtNnotifyUnhighlights, XtCBoolean, XtRBoolean, sizeof(Boolean),
  224.    MultiListFieldOffset(notify_unhighlights), XtRString, "True"},
  225.   {XtNnotifyOpens, XtCBoolean, XtRBoolean, sizeof(Boolean),
  226.    MultiListFieldOffset(notify_opens), XtRString, "True"},
  227.   {XtNshadeSurplus, XtCBoolean, XtRBoolean, sizeof(Boolean),
  228.    MultiListFieldOffset(shade_surplus), XtRString, "True"},
  229.  
  230.   {XtNcolumnWidth, XtCValue, XtRDimension, sizeof(Dimension),
  231.    MultiListFieldOffset(col_width), XtRImmediate, (caddr_t) 0},
  232.   {XtNrowHeight, XtCValue, XtRDimension, sizeof(Dimension),
  233.    MultiListFieldOffset(row_height), XtRImmediate, (caddr_t) 0},
  234. };
  235.  
  236. /*===========================================================================*
  237.  
  238.         A C T I O N    A N D    T R A N S L A T I O N    T A B L E S
  239.  
  240.  *===========================================================================*/
  241.  
  242.  
  243. static char     defaultTranslations[] =
  244. "    Shift<Btn1Down>:            Toggle()\n\
  245.     <Btn1Down>:                Set()\n\
  246.     <Btn3Down>:                Unset()\n\
  247.     <Btn1Up>:                Notify()\n\
  248.     <Btn3Up>:                Notify()";
  249.  
  250. static XtActionsRec actions[] =
  251. {
  252.   {"Notify", (XtActionProc) Notify},
  253.   {"Set", (XtActionProc) Set},
  254.   {"Toggle", (XtActionProc) Toggle},
  255.   {"Open", (XtActionProc) Open},
  256.   {"OpenMany", (XtActionProc) OpenMany},
  257.   {"Unset", (XtActionProc) Unset},
  258.   {NULL, (XtActionProc) NULL}
  259. };
  260.  
  261. /*===========================================================================*
  262.  
  263.                     C L A S S    A L L O C A T I O N
  264.  
  265.  *===========================================================================*/
  266.  
  267. XfwfMultiListClassRec xfwfMultiListClassRec =
  268. {
  269.   {
  270.     /* superclass        */ (WidgetClass) SUPERCLASS,
  271.     /* class_name        */ "XfwfMultiList",
  272.     /* widget_size        */ sizeof(XfwfMultiListRec),
  273.     /* class_initialize    */ NULL,
  274.     /* class_part_initialize*/ NULL,
  275.     /* class_inited        */ FALSE,
  276.     /* initialize        */ (XtInitProc) Initialize,
  277.     /* initialize_hook    */ NULL,
  278.     /* realize        */ XtInheritRealize,
  279.     /* actions        */ actions,
  280.     /* num_actions        */ XtNumber(actions),
  281.     /* resources        */ resources,
  282.     /* resource_count    */ XtNumber(resources),
  283.     /* xrm_class        */ NULLQUARK,
  284.     /* compress_motion    */ TRUE,
  285.     /* compress_exposure    */ FALSE,
  286.     /* compress_enterleave    */ TRUE,
  287.     /* visible_interest    */ FALSE,
  288.     /* destroy        */ NULL,
  289.     /* resize        */ (XtWidgetProc) Resize,
  290.     /* expose        */ (XtExposeProc) Redisplay,
  291.     /* set_values        */ (XtSetValuesFunc) SetValues,
  292.     /* set_values_hook    */ NULL,
  293.     /* set_values_almost    */ XtInheritSetValuesAlmost,
  294.     /* get_values_hook    */ NULL,
  295.     /* accept_focus        */ NULL,
  296.     /* version        */ XtVersion,
  297.     /* callback_private    */ NULL,
  298.     /* tm_table        */ defaultTranslations,
  299.     /* query_geometry       */ (XtGeometryHandler)
  300.     PreferredGeometry,
  301.     /* display_accelerator  */ XtInheritDisplayAccelerator,
  302.     /* extension            */ NULL
  303.   },                /* Core Part */
  304.   {
  305.     /* change_sensitive     */ XtInheritChangeSensitive
  306.   }
  307. };
  308.  
  309. WidgetClass     xfwfMultiListWidgetClass = (WidgetClass) & xfwfMultiListClassRec;
  310.  
  311. /*===========================================================================*
  312.  
  313.                        T O O L K I T    M E T H O D S
  314.  
  315.  *===========================================================================*/
  316.  
  317. /*---------------------------------------------------------------------------*
  318.  
  319.     Initialize()
  320.  
  321.     This procedure is called by the X toolkit to initialize
  322.     the widget instance.  The hook to this routine is in the
  323.     initialize part of the core part of the class.
  324.  
  325.  *---------------------------------------------------------------------------*/
  326.  
  327. /* ARGSUSED */
  328. static void
  329. Initialize(request, new)
  330.      Widget          request,
  331.                      new;
  332. {
  333.   XfwfMultiListWidget mlw;
  334.  
  335.   mlw = (XfwfMultiListWidget) new;
  336.   CreateNewGCs(mlw);
  337.   InitializeNewData(mlw);
  338.   RecalcCoords(mlw, (MultiListWidth(mlw) == 0),
  339.            (MultiListHeight(mlw) == 0));
  340. }                /* Initialize */
  341.  
  342.  
  343. /*---------------------------------------------------------------------------*
  344.  
  345.     Redisplay(mlw,event,rectangle_union)
  346.  
  347.     This routine redraws the MultiList widget <mlw> based on the exposure
  348.     region requested in <event>.
  349.  
  350.  *---------------------------------------------------------------------------*/
  351.  
  352. /* ARGSUSED */
  353. static void
  354. Redisplay(mlw, event, rectangle_union)
  355.      XfwfMultiListWidget mlw;
  356.      XEvent         *event;
  357.      Region          rectangle_union;
  358. {
  359.   GC              shade_gc;
  360.   int             i,
  361.                   x1,
  362.                   y1,
  363.                   w,
  364.                   h,
  365.                   x2,
  366.                   y2,
  367.                   row,
  368.                   col,
  369.                   ul_row,
  370.                   ul_col,
  371.                   lr_row,
  372.                   lr_col;
  373.  
  374.   if (MultiListShadeSurplus(mlw))
  375.     shade_gc = MultiListGrayGC(mlw);
  376.   else
  377.     shade_gc = MultiListEraseGC(mlw);
  378.   if (event == NULL) {
  379.     XFillRectangle(XtDisplay(mlw), XtWindow(mlw), shade_gc, 0, 0,
  380.            MultiListWidth(mlw), MultiListHeight(mlw));
  381.     for (i = 0; i < MultiListNumItems(mlw); i++)
  382.       RedrawItem(mlw, i);
  383.   }
  384.   else {
  385.     x1 = event->xexpose.x;
  386.     y1 = event->xexpose.y;
  387.     w = event->xexpose.width;
  388.     h = event->xexpose.height;
  389.     x2 = x1 + w;
  390.     y2 = y1 + h;
  391.     XFillRectangle(XtDisplay(mlw), XtWindow(mlw),
  392.            shade_gc, x1, y1, w, h);
  393.     PixelToRowColumn(mlw, x1, y1, &ul_row, &ul_col);
  394.     PixelToRowColumn(mlw, x2, y2, &lr_row, &lr_col);
  395.     lr_row = min(lr_row, MultiListNumRows(mlw) - 1);
  396.     lr_col = min(lr_col, MultiListNumCols(mlw) - 1);
  397.     for (col = ul_col; col <= lr_col; col++) {
  398.       for (row = ul_row; row <= lr_row; row++) {
  399.     RedrawRowColumn(mlw, row, col);
  400.       }
  401.     }
  402.   }
  403. }                /* End Redisplay */
  404.  
  405.  
  406. /*---------------------------------------------------------------------------*
  407.  
  408.     PreferredGeometry(mlw,parent_idea,our_idea)
  409.  
  410.     This routine is called by the parent to tell us about the
  411.     parent's idea of our width and/or height.  We then suggest
  412.     our preference through <our_idea> and return the information
  413.     to the parent.
  414.  
  415.  *---------------------------------------------------------------------------*/
  416.  
  417. static          XtGeometryResult
  418. PreferredGeometry(mlw, parent_idea, our_idea)
  419.      XfwfMultiListWidget mlw;
  420.      XtWidgetGeometry *parent_idea,
  421.                     *our_idea;
  422. {
  423.   Dimension       nw,
  424.                   nh;
  425.   Boolean         parent_wants_w,
  426.                   parent_wants_h,
  427.                   we_changed_size;
  428.  
  429.   parent_wants_w = (parent_idea->request_mode) & CWWidth;
  430.   parent_wants_h = (parent_idea->request_mode) & CWHeight;
  431.  
  432.   if (parent_wants_w)
  433.     nw = parent_idea->width;
  434.   else
  435.     nw = MultiListWidth(mlw);
  436.  
  437.   if (parent_wants_h)
  438.     nh = parent_idea->height;
  439.   else
  440.     nh = MultiListHeight(mlw);
  441.  
  442.   our_idea->request_mode = 0;
  443.   if (!parent_wants_w && !parent_wants_h)
  444.     return (XtGeometryYes);
  445.  
  446.   we_changed_size = Layout(mlw, !parent_wants_w, !parent_wants_h, &nw, &nh);
  447.   our_idea->request_mode |= (CWWidth | CWHeight);
  448.   our_idea->width = nw;
  449.   our_idea->height = nh;
  450.  
  451.   if (we_changed_size)
  452.     return (XtGeometryAlmost);
  453.   else
  454.     return (XtGeometryYes);
  455. }                /* End PreferredGeometry */
  456.  
  457.  
  458. /*---------------------------------------------------------------------------*
  459.  
  460.     Resize(mlw)
  461.  
  462.     This function is called when the widget is being resized.  It
  463.     recalculates the layout of the widget.
  464.  
  465.  *---------------------------------------------------------------------------*/
  466.  
  467. static void
  468. Resize(mlw)
  469.      XfwfMultiListWidget mlw;
  470. {
  471.   Dimension       width,
  472.                   height;
  473.  
  474.   width = MultiListWidth(mlw);
  475.   height = MultiListHeight(mlw);
  476.   Layout(mlw, False, False, &width, &height);
  477. }                /* End Resize */
  478.  
  479.  
  480. /*---------------------------------------------------------------------------*
  481.  
  482.     SetValues(cpl,rpl,npl)
  483.  
  484.     This routine is called when the user is changing resources.  <cpl>
  485.     is the current widget before the user's changes have been instituted.
  486.     <rpl> includes the original changes as requested by the user.  <npl>
  487.     is the new resulting widget with the requested changes and with all
  488.     superclass changes already made.
  489.  
  490.  *---------------------------------------------------------------------------*/
  491.  
  492. static          Boolean
  493. SetValues(cpl, rpl, npl)
  494.      XfwfMultiListWidget cpl,
  495.                      rpl,
  496.                      npl;
  497. {
  498.   Boolean         redraw,
  499.                   recalc;
  500.  
  501.   redraw = False;
  502.   recalc = False;
  503.  
  504.   /* Graphic Context Changes */
  505.  
  506.   if ((MultiListFG(cpl) != MultiListFG(npl)) ||
  507.       (MultiListBG(cpl) != MultiListBG(npl)) ||
  508.       (MultiListHighlightFG(cpl) != MultiListHighlightFG(npl)) ||
  509.       (MultiListHighlightBG(cpl) != MultiListHighlightBG(npl)) ||
  510.       (MultiListFont(cpl) != MultiListFont(npl))) {
  511.     XtDestroyGC(MultiListEraseGC(cpl));
  512.     XtDestroyGC(MultiListDrawGC(cpl));
  513.     XtDestroyGC(MultiListHighlightForeGC(cpl));
  514.     XtDestroyGC(MultiListHighlightBackGC(cpl));
  515.     XtDestroyGC(MultiListGrayGC(cpl));
  516.     CreateNewGCs(npl);
  517.     redraw = True;
  518.   }
  519.  
  520.   /* Changes That Require Data Initialization */
  521.  
  522.   if ((MultiListList(cpl) != MultiListList(npl)) ||
  523.       (MultiListSensitiveArray(cpl) != MultiListSensitiveArray(npl)) ||
  524.       (MultiListSensitive(cpl) != MultiListSensitive(npl)) ||
  525.       (MultiListAncesSensitive(cpl) != MultiListAncesSensitive(npl)) ||
  526.       (MultiListNumItems(cpl) != MultiListNumItems(npl)) ||
  527.       (MultiListMaxSelectable(cpl) != MultiListMaxSelectable(npl))) {
  528.     DestroyOldData(cpl);
  529.     InitializeNewData(npl);
  530.     recalc = True;
  531.     redraw = True;
  532.   }
  533.  
  534.   /* Changes That Require Recalculating Coordinates */
  535.  
  536.   if ((MultiListWidth(cpl) != MultiListWidth(npl)) ||
  537.       (MultiListHeight(cpl) != MultiListHeight(npl)) ||
  538.       (MultiListColumnSpace(cpl) != MultiListColumnSpace(npl)) ||
  539.       (MultiListRowSpace(cpl) != MultiListRowSpace(npl)) ||
  540.       (MultiListDefaultCols(cpl) != MultiListDefaultCols(npl)) ||
  541.       ((MultiListForceCols(cpl) != MultiListForceCols(npl)) &&
  542.        (MultiListNumCols(cpl) != MultiListNumCols(npl))) ||
  543.       (MultiListRowMajor(cpl) != MultiListRowMajor(npl)) ||
  544.       (MultiListFont(cpl) != MultiListFont(npl)) ||
  545.       (MultiListLongest(cpl) != MultiListLongest(npl))) {
  546.     recalc = True;
  547.     redraw = True;
  548.   }
  549.  
  550.   if (MultiListColWidth(cpl) != MultiListColWidth(npl)) {
  551.     XtWarning("columnWidth Resource Is Read-Only");
  552.     MultiListColWidth(npl) = MultiListColWidth(cpl);
  553.   }
  554.   if (MultiListRowHeight(cpl) != MultiListRowHeight(npl)) {
  555.     XtWarning("rowHeight Resource Is Read-Only");
  556.     MultiListRowHeight(npl) = MultiListRowHeight(cpl);
  557.   }
  558.  
  559.   if (recalc) {
  560.     RecalcCoords(npl, !MultiListWidth(npl), !MultiListHeight(npl));
  561.   }
  562.  
  563.   if (!XtIsRealized((Widget) cpl))
  564.     return (False);
  565.   else
  566.     return (redraw);
  567. }                /* End SetValues */
  568.  
  569. /*===========================================================================*
  570.  
  571.                   D A T A    I N I T I A L I Z A T I O N
  572.  
  573.  *===========================================================================*/
  574.  
  575. /*---------------------------------------------------------------------------*
  576.  
  577.     DestroyOldData(mlw)
  578.  
  579.     This routine frees the internal list item array and sets the
  580.     item count to 0.  This is normally done immediately before
  581.     calling InitializeNewData() to rebuild the internal item
  582.     array from new user specified arrays.
  583.  
  584.  *---------------------------------------------------------------------------*/
  585.  
  586. static void
  587. DestroyOldData(mlw)
  588.      XfwfMultiListWidget mlw;
  589. {
  590.   int             i;
  591.  
  592.   if (MultiListItemArray(mlw) != NULL) {    /* Free Old List */
  593.     for (i = 0; i < MultiListNumItems(mlw); i++) {
  594.       free(MultiListItemString(MultiListNthItem(mlw, i)));
  595.     }
  596.     free(MultiListItemArray(mlw));
  597.   }
  598.   if (MultiListSelArray(mlw) != NULL)
  599.     free(MultiListSelArray(mlw));
  600.   MultiListSelArray(mlw) = NULL;
  601.   MultiListNumSelected(mlw) = 0;
  602.   MultiListItemArray(mlw) = NULL;
  603.   MultiListNumItems(mlw) = 0;
  604. }                /* End DestroyOldData */
  605.  
  606.  
  607. /*---------------------------------------------------------------------------*
  608.  
  609.     InitializeNewData(mlw)
  610.  
  611.     This routine takes a MultiList widget <mlw> and builds up new
  612.     data item tables based on the string list and the sensitivity array.
  613.     All previous data should have already been freed.  If the number
  614.     of items is 0, they will be counted, so the array must be NULL
  615.     terminated.  If the list of strings is NULL, this is treated as
  616.     a list of 0 elements.  If the sensitivity array is NULL, all
  617.     items are treated as sensitive.
  618.  
  619.     When this routine is done, the string list and sensitivity array
  620.     fields will all be set to NULL, and the widget will not reference
  621.     them again.
  622.  
  623.  *---------------------------------------------------------------------------*/
  624.  
  625. static void
  626. InitializeNewData(mlw)
  627.      XfwfMultiListWidget mlw;
  628. {
  629.   int             i;
  630.   XfwfMultiListItem *item;
  631.   String         *string_array;
  632.  
  633.   string_array = MultiListList(mlw);
  634.   if (MultiListNumItems(mlw) == 0) {    /* Count Elements */
  635.     if (MultiListList(mlw) == NULL) {    /* No elements */
  636.       MultiListNumItems(mlw) = 0;
  637.     }
  638.     else {
  639.       for (i = 0; string_array[i] != NULL; i++);
  640.       MultiListNumItems(mlw) = i;
  641.     }
  642.   }
  643.   if (MultiListNumItems(mlw) == 0) {    /* No Items */
  644.     MultiListItemArray(mlw) = NULL;
  645.   }
  646.   else {
  647.     MultiListItemArray(mlw) =
  648.       TypeAlloc(XfwfMultiListItem, MultiListNumItems(mlw));
  649.     for (i = 0; i < MultiListNumItems(mlw); i++) {
  650.       item = MultiListNthItem(mlw, i);
  651.       if (MultiListSensitiveArray(mlw) == NULL ||
  652.       (MultiListSensitiveArray(mlw)[i] == True)) {
  653.     MultiListItemSensitive(item) = True;
  654.       }
  655.       else {
  656.     MultiListItemSensitive(item) = False;
  657.       }
  658.       MultiListItemString(item) = StrCopy(string_array[i]);
  659.       MultiListItemHighlighted(item) = False;
  660.     }
  661.   }
  662.   if (MultiListMaxSelectable(mlw) == 0) {
  663.     MultiListSelArray(mlw) = NULL;
  664.     MultiListNumSelected(mlw) = 0;
  665.   }
  666.   else {
  667.     MultiListSelArray(mlw) =
  668.       TypeAlloc(int, MultiListMaxSelectable(mlw));
  669.     MultiListNumSelected(mlw) = 0;
  670.   }
  671.  
  672.   MultiListList(mlw) = NULL;
  673.   MultiListSensitiveArray(mlw) = NULL;
  674. }                /* End InitializeNewData */
  675.  
  676.  
  677. /*---------------------------------------------------------------------------*
  678.  
  679.     CreateNewGCs(mlw)
  680.  
  681.     This routine takes a MultiList widget <mlw> and creates a new set of
  682.     graphic contexts for the widget based on the colors, fonts, etc.
  683.     in the widget.  Any previous GCs are assumed to have already been
  684.     destroyed.
  685.  
  686.  *---------------------------------------------------------------------------*/
  687.  
  688. static void
  689. CreateNewGCs(mlw)
  690.      XfwfMultiListWidget mlw;
  691. {
  692.   XGCValues       values;
  693.   unsigned int    attribs;
  694.  
  695.   attribs = GCForeground | GCBackground | GCFont;
  696.   values.foreground = MultiListFG(mlw);
  697.   values.background = MultiListBG(mlw);
  698.   values.font = MultiListFont(mlw)->fid;
  699.   MultiListDrawGC(mlw) = XtGetGC((Widget) mlw, attribs, &values);
  700.  
  701.   values.foreground = MultiListBG(mlw);
  702.   MultiListEraseGC(mlw) = XtGetGC((Widget) mlw, attribs, &values);
  703.  
  704.   values.foreground = MultiListHighlightFG(mlw);
  705.   values.background = MultiListHighlightBG(mlw);
  706.   MultiListHighlightForeGC(mlw) = XtGetGC((Widget) mlw, attribs, &values);
  707.  
  708.   values.foreground = MultiListHighlightBG(mlw);
  709.   values.background = MultiListHighlightBG(mlw);
  710.   MultiListHighlightBackGC(mlw) = XtGetGC((Widget) mlw, attribs, &values);
  711.  
  712.   attribs |= GCTile | GCFillStyle;
  713.   values.foreground = MultiListFG(mlw);
  714.   values.background = MultiListBG(mlw);
  715.   values.fill_style = FillTiled;
  716.   values.tile = XmuCreateStippledPixmap(XtScreen(mlw), MultiListFG(mlw),
  717.                      MultiListBG(mlw), MultiListDepth(mlw));
  718.  
  719.   MultiListGrayGC(mlw) = XtGetGC((Widget) mlw, attribs, &values);
  720. }                /* End CreateNewGCs */
  721.  
  722. /*===========================================================================*
  723.  
  724.         L A Y O U T    A N D    G E O M E T R Y    M A N A G E M E N T
  725.  
  726.  *===========================================================================*/
  727.  
  728. /*---------------------------------------------------------------------------*
  729.  
  730.         RecalcCoords(mlw,width_changeable,height_changeable)
  731.  
  732.     This routine takes a MultiList widget <mlw> and recalculates
  733.     the coordinates, and item placement based on the current
  734.     width, height, and list of items.  The <width_changeable> and
  735.     <height_changeable> indicate if the width and/or height can
  736.     be arbitrarily set.
  737.  
  738.     This routine requires that the internal list data be initialized.
  739.  
  740.  *---------------------------------------------------------------------------*/
  741.  
  742. static void
  743. RecalcCoords(mlw, width_changeable, height_changeable)
  744.      XfwfMultiListWidget mlw;
  745.      int             width_changeable,
  746.                      height_changeable;
  747. {
  748.   String          str;
  749.   Dimension       width,
  750.                   height;
  751.   register int    i,
  752.                   text_width;
  753.  
  754.   width = MultiListWidth(mlw);
  755.   height = MultiListHeight(mlw);
  756.   if (MultiListNumItems(mlw) != 0 && MultiListLongest(mlw) == 0) {
  757.     for (i = 0; i < MultiListNumItems(mlw); i++) {
  758.       str = MultiListItemString(MultiListNthItem(mlw, i));
  759.       text_width = FontW(MultiListFont(mlw), str);
  760.       MultiListLongest(mlw) = max(MultiListLongest(mlw),
  761.                   text_width);
  762.     }
  763.   }
  764.   if (Layout(mlw, width_changeable, height_changeable, &width, &height)) {
  765.     NegotiateSizeChange(mlw, width, height);
  766.   }
  767. }                /* End RecalcCoords */
  768.  
  769.  
  770. /*---------------------------------------------------------------------------*
  771.  
  772.         NegotiateSizeChange(mlw,width,height)
  773.  
  774.     This routine tries to change the MultiList widget <mlw> to have the
  775.     new size <width> by <height>.  A negotiation will takes place
  776.     to try to change the size.  The resulting size is not necessarily
  777.     the requested size.
  778.  
  779.  *---------------------------------------------------------------------------*/
  780.  
  781. static void
  782. NegotiateSizeChange(mlw, width, height)
  783.      XfwfMultiListWidget mlw;
  784.      int             width,
  785.                      height;
  786. {
  787.   int             attempt_number;
  788.   Boolean         w_fixed,
  789.                   h_fixed;
  790.   Dimension      *w_ptr,
  791.                  *h_ptr;
  792.  
  793.   XtWidgetGeometry request,
  794.                   reply;
  795.  
  796.   request.request_mode = CWWidth | CWHeight;
  797.   request.width = width;
  798.   request.height = height;
  799.  
  800.   for (attempt_number = 1; attempt_number <= 3; attempt_number++) {
  801.     switch (XtMakeGeometryRequest((Widget) mlw, &request, &reply)) {
  802.     case XtGeometryYes:
  803.     case XtGeometryNo:
  804.       return;
  805.     case XtGeometryAlmost:
  806.       switch (attempt_number) {
  807.       case 1:
  808.     w_fixed = (request.width != reply.width);
  809.     h_fixed = (request.height != reply.height);
  810.     w_ptr = &(reply.width);
  811.     h_ptr = &(reply.height);
  812.     Layout(mlw, !w_fixed, !h_fixed, w_ptr, h_ptr);
  813.     break;
  814.       case 2:
  815.     w_ptr = &(reply.width);
  816.     h_ptr = &(reply.height);
  817.     Layout(mlw, False, False, w_ptr, h_ptr);
  818.     break;
  819.       case 3:
  820.     return;
  821.       }
  822.       break;
  823.     default:
  824.       XtAppWarning(XtWidgetToApplicationContext((Widget) mlw),
  825.            "MultiList Widget: Unknown geometry return.");
  826.       break;
  827.     }
  828.     request = reply;
  829.   }
  830. }                /* End NegotiateSizeChange */
  831.  
  832.  
  833. /*---------------------------------------------------------------------------*
  834.  
  835.     Boolean Layout(mlw,w_changeable,h_changeable,w_ptr,h_ptr)
  836.  
  837.     This routine tries to generate a layout for the MultiList widget
  838.     <mlw>.  The Layout routine is free to arbitrarily set the width
  839.     or height if the corresponding variables <w_changeable> and
  840.     <h_changeable> are set True.  Otherwise the original width or
  841.     height in <w_ptr> and <h_ptr> are used as fixed values.  The
  842.     resulting new width and height are stored back through the
  843.     <w_ptr> and <h_ptr> pointers.  False is returned if no size
  844.     change was done, True is returned otherwise.
  845.  
  846.  *---------------------------------------------------------------------------*/
  847.  
  848. static          Boolean
  849. Layout(mlw, w_changeable, h_changeable, w_ptr, h_ptr)
  850.      XfwfMultiListWidget mlw;
  851.      int             w_changeable,
  852.                      h_changeable;
  853.      Dimension      *w_ptr,
  854.                     *h_ptr;
  855. {
  856.   Boolean         size_changed = False;
  857.  
  858.   /*
  859.      * If force columns is set, then always use the number
  860.      * of columns specified by default_cols.
  861.      */
  862.  
  863.   MultiListColWidth(mlw) = MultiListLongest(mlw) +
  864.     MultiListColumnSpace(mlw);
  865.   MultiListRowHeight(mlw) = FontH(MultiListFont(mlw)) +
  866.     MultiListRowSpace(mlw);
  867.   if (MultiListForceCols(mlw)) {
  868.     MultiListNumCols(mlw) = max(MultiListDefaultCols(mlw), 1);
  869.     if (MultiListNumItems(mlw) == 0)
  870.       MultiListNumRows(mlw) = 1;
  871.     else
  872.       MultiListNumRows(mlw) = (MultiListNumItems(mlw) - 1) /
  873.     MultiListNumCols(mlw) + 1;
  874.     if (w_changeable) {
  875.       *w_ptr = MultiListNumCols(mlw) *
  876.     MultiListColWidth(mlw);
  877.       size_changed = True;
  878.     }
  879.     else {
  880.       MultiListColWidth(mlw) = (int)*w_ptr /
  881.     MultiListNumCols(mlw);
  882.     }
  883.     if (h_changeable) {
  884.       *h_ptr = MultiListNumRows(mlw) *
  885.     MultiListRowHeight(mlw);
  886.       size_changed = True;
  887.     }
  888.     return (size_changed);
  889.   }
  890.  
  891.   /*
  892.      * If both width and height are free to change then use
  893.      * default_cols to determine the number of columns and set
  894.      * the new width and height to just fit the window.
  895.      */
  896.  
  897.   if (w_changeable && h_changeable) {
  898.     MultiListNumCols(mlw) = max(MultiListDefaultCols(mlw), 1);
  899.     if (MultiListNumItems(mlw) == 0)
  900.       MultiListNumRows(mlw) = 1;
  901.     else
  902.       MultiListNumRows(mlw) = (MultiListNumItems(mlw) - 1) /
  903.     MultiListNumCols(mlw) + 1;
  904.     *w_ptr = MultiListNumCols(mlw) * MultiListColWidth(mlw);
  905.     *h_ptr = MultiListNumRows(mlw) * MultiListRowHeight(mlw);
  906.     return (True);
  907.   }
  908.  
  909.   /*
  910.      * If the width is fixed then use it to determine the
  911.      * number of columns.  If the height is free to move
  912.      * (width still fixed) then resize the height of the
  913.      * widget to fit the current MultiList exactly.
  914.      */
  915.  
  916.   if (!w_changeable) {
  917.     MultiListNumCols(mlw) = *w_ptr / MultiListColWidth(mlw);
  918.     MultiListNumCols(mlw) = max(MultiListNumCols(mlw), 1);
  919.     MultiListNumRows(mlw) = (MultiListNumItems(mlw) - 1) /
  920.       MultiListNumCols(mlw) + 1;
  921.     MultiListColWidth(mlw) = (int)*w_ptr / MultiListNumCols(mlw);
  922.     if (h_changeable) {
  923.       *h_ptr = MultiListNumRows(mlw) * MultiListRowHeight(mlw);
  924.       size_changed = True;
  925.     }
  926.     return (size_changed);
  927.   }
  928.  
  929.   /*
  930.      * The last case is xfree and !yfree we use the height to
  931.      * determine the number of rows and then set the width to
  932.      * just fit the resulting number of columns.
  933.      */
  934.  
  935.   MultiListNumRows(mlw) = *h_ptr / MultiListRowHeight(mlw);
  936.   MultiListNumRows(mlw) = max(MultiListNumRows(mlw), 1);
  937.   MultiListNumCols(mlw) = (MultiListNumItems(mlw) - 1) /
  938.     MultiListNumRows(mlw) + 1;
  939.   *w_ptr = MultiListNumCols(mlw) * MultiListColWidth(mlw);
  940.   return (True);
  941. }                /* End Layout */
  942.  
  943. /*===========================================================================*
  944.  
  945.                     R E D R A W    R O U T I N E S
  946.  
  947.  *===========================================================================*/
  948.  
  949. /*---------------------------------------------------------------------------*
  950.  
  951.     RedrawAll(mlw)
  952.  
  953.     This routine simple calls Redisplay to redraw the entire
  954.     MultiList widget <mlw>.
  955.  
  956.  *---------------------------------------------------------------------------*/
  957.  
  958. static void
  959. RedrawAll(mlw)
  960.      XfwfMultiListWidget mlw;
  961. {
  962.   Redisplay(mlw, NULL, NULL);
  963. }                /* End RedrawAll */
  964.  
  965.  
  966. /*---------------------------------------------------------------------------*
  967.  
  968.     RedrawItem(mlw,item_index)
  969.  
  970.     This routine redraws the item with index <item_index> in the
  971.     MultiList widget <mlw>.  If the item number is bad, nothing is drawn.
  972.  
  973.  *---------------------------------------------------------------------------*/
  974.  
  975. static void
  976. RedrawItem(mlw, item_index)
  977.      XfwfMultiListWidget mlw;
  978.      int             item_index;
  979. {
  980.   int             row,
  981.                   column;
  982.  
  983.   if (ItemToRowColumn(mlw, item_index, &row, &column)) {
  984.     RedrawRowColumn(mlw, row, column);
  985.   }
  986. }                /* End RedrawItem */
  987.  
  988.  
  989. /*---------------------------------------------------------------------------*
  990.  
  991.     RedrawRowColumn(mlw,row,column)
  992.  
  993.     This routine paints the item in row/column position <row>,<column>
  994.     on the MultiList widget <mlw>.  If the row/column coordinates are
  995.     outside the widget, nothing is drawn.  If the position is empty,
  996.     blank space is drawn.
  997.  
  998.  *---------------------------------------------------------------------------*/
  999.  
  1000. static void
  1001. RedrawRowColumn(mlw, row, column)
  1002.      XfwfMultiListWidget mlw;
  1003.      int             row,
  1004.                      column;
  1005. {
  1006.   GC              bg_gc,
  1007.                   fg_gc;
  1008.   XfwfMultiListItem *item;
  1009.   int             ul_x,
  1010.                   ul_y,
  1011.                   str_x,
  1012.                   str_y,
  1013.                   w,
  1014.                   h,
  1015.                   item_index,
  1016.                   has_item,
  1017.                   text_h;
  1018.  
  1019.   if (!XtIsRealized((Widget) mlw))
  1020.     return;
  1021.   has_item = RowColumnToItem(mlw, row, column, &item_index);
  1022.   RowColumnToPixels(mlw, row, column, &ul_x, &ul_y, &w, &h);
  1023.  
  1024.   if (has_item == False) {     /* No Item */
  1025.     if (MultiListShadeSurplus(mlw))
  1026.       bg_gc = MultiListGrayGC(mlw);
  1027.     else
  1028.       bg_gc = MultiListEraseGC(mlw);
  1029.   }
  1030.   else {
  1031.     item = MultiListNthItem(mlw, item_index);
  1032.     if (!MultiListItemSensitive(item)) {    /* Disabled */
  1033.       bg_gc = MultiListEraseGC(mlw);
  1034.       fg_gc = MultiListGrayGC(mlw);
  1035.     }
  1036.     else if (MultiListItemHighlighted(item)) {    /* Selected */
  1037.       bg_gc = MultiListHighlightBackGC(mlw);
  1038.       fg_gc = MultiListHighlightForeGC(mlw);
  1039.     }
  1040.     else {               /* Normal */
  1041.       bg_gc = MultiListEraseGC(mlw);
  1042.       fg_gc = MultiListDrawGC(mlw);
  1043.     }
  1044.   }
  1045.   XFillRectangle(XtDisplay(mlw), XtWindow(mlw), bg_gc, ul_x, ul_y, w, h);
  1046.   if (has_item == True) {
  1047.     text_h = min(
  1048.           (int)(FontH(MultiListFont(mlw)) + MultiListRowSpace(mlw)),
  1049.           (int)MultiListRowHeight(mlw));
  1050.     str_x = ul_x + MultiListColumnSpace(mlw) / 2;
  1051.     str_y = ul_y + FontAscent(MultiListFont(mlw)) +
  1052.       (int)(MultiListRowHeight(mlw) - text_h) / 2;
  1053.     XDrawString(XtDisplay(mlw), XtWindow(mlw), fg_gc,
  1054.         str_x, str_y, MultiListItemString(item),
  1055.         strlen(MultiListItemString(item)));
  1056.   }
  1057. }                /* End RedrawRowColumn */
  1058.  
  1059. /*===========================================================================*
  1060.  
  1061.                I T E M    L O C A T I O N    R O U T I N E S
  1062.  
  1063.  *===========================================================================*/
  1064.  
  1065. /*---------------------------------------------------------------------------*
  1066.  
  1067.     void PixelToRowColumn(mlw,x,y,row_ptr,column_ptr)
  1068.  
  1069.     This routine takes pixel coordinates <x>, <y> and converts
  1070.     the pixel coordinate into a row/column coordinate.  This row/column
  1071.     coordinate can then easily be converted into the specific item
  1072.     in the list via the function RowColumnToItem().
  1073.  
  1074.     If the pixel lies in blank space outside of the items, the
  1075.     row & column numbers will be outside of the range of normal
  1076.     row & columns numbers, but will correspond to the row & column
  1077.     of the item, if an item was actually there.
  1078.  
  1079.  *---------------------------------------------------------------------------*/
  1080.  
  1081. static void
  1082. PixelToRowColumn(mlw, x, y, row_ptr, column_ptr)
  1083.      XfwfMultiListWidget mlw;
  1084.      int             x,
  1085.                      y,
  1086.                     *row_ptr,
  1087.                     *column_ptr;
  1088. {
  1089.   *row_ptr = y / (int)MultiListRowHeight(mlw);
  1090.   *column_ptr = x / (int)MultiListColWidth(mlw);
  1091. }                /* End PixelToRowColumn */
  1092.  
  1093. /*---------------------------------------------------------------------------*
  1094.  
  1095.     void RowColumnToPixels(mlw,row,col,x_ptr,y_ptr,w_ptr,h_ptr)
  1096.  
  1097.     This routine takes a row/column coordinate <row>,<col> and
  1098.     converts it into the bounding pixel rectangle which is returned.
  1099.  
  1100.  *---------------------------------------------------------------------------*/
  1101.  
  1102. static void
  1103. RowColumnToPixels(mlw, row, col, x_ptr, y_ptr, w_ptr, h_ptr)
  1104.      XfwfMultiListWidget mlw;
  1105.      int             row,
  1106.                      col,
  1107.                     *x_ptr,
  1108.                     *y_ptr,
  1109.                     *w_ptr,
  1110.                     *h_ptr;
  1111. {
  1112.   *x_ptr = col * MultiListColWidth(mlw);
  1113.   *y_ptr = row * MultiListRowHeight(mlw);
  1114.   *w_ptr = MultiListColWidth(mlw);
  1115.   *h_ptr = MultiListRowHeight(mlw);
  1116. }                /* End RowColumnToPixels */
  1117.  
  1118. /*---------------------------------------------------------------------------*
  1119.  
  1120.     Boolean RowColumnToItem(mlw,row,column,item_ptr)
  1121.  
  1122.     This routine takes a row number <row> and a column number <column>
  1123.     and tries to resolve this row and column into the index of the
  1124.     item in this position of the MultiList widget <mlw>.  The resulting
  1125.     item index is placed through <item_ptr>.  If there is no item at
  1126.     this location, False is returned, else True is returned.
  1127.  
  1128.  *---------------------------------------------------------------------------*/
  1129.  
  1130. static          Boolean
  1131. RowColumnToItem(mlw, row, column, item_ptr)
  1132.      XfwfMultiListWidget mlw;
  1133.      int             row,
  1134.                      column,
  1135.                     *item_ptr;
  1136. {
  1137.   register int    x_stride,
  1138.                   y_stride;
  1139.  
  1140.   if (row < 0 || row >= MultiListNumRows(mlw) ||
  1141.       column < 0 || column >= MultiListNumCols(mlw)) {
  1142.     return (False);
  1143.   }
  1144.   if (MultiListRowMajor(mlw)) {
  1145.     x_stride = 1;
  1146.     y_stride = MultiListNumCols(mlw);
  1147.   }
  1148.   else {
  1149.     x_stride = MultiListNumRows(mlw);
  1150.     y_stride = 1;
  1151.   }
  1152.   *item_ptr = row * y_stride + column * x_stride;
  1153.   if (*item_ptr >= MultiListNumItems(mlw))
  1154.     return (False);
  1155.   else
  1156.     return (True);
  1157. }                /* End RowColumnToItem */
  1158.  
  1159.  
  1160. /*---------------------------------------------------------------------------*
  1161.  
  1162.     Boolean ItemToRowColumn(mlw,item_index,row_ptr,column_ptr)
  1163.  
  1164.     This routine takes an item number <item_index> and attempts
  1165.     to convert the index into row and column numbers stored through
  1166.     <row_ptr> and <column_ptr>.  If the item number does not
  1167.     corespond to a valid item, False is returned, else True is
  1168.     returned.
  1169.  
  1170.  *---------------------------------------------------------------------------*/
  1171.  
  1172. static          Boolean
  1173. ItemToRowColumn(mlw, item_index, row_ptr, column_ptr)
  1174.      XfwfMultiListWidget mlw;
  1175.      int             item_index,
  1176.                     *row_ptr,
  1177.                     *column_ptr;
  1178. {
  1179.   if (item_index < 0 || item_index >= MultiListNumItems(mlw)) {
  1180.     return (False);
  1181.   }
  1182.   if (MultiListRowMajor(mlw)) {
  1183.     *row_ptr = item_index / MultiListNumCols(mlw);
  1184.     *column_ptr = item_index % MultiListNumCols(mlw);
  1185.   }
  1186.   else {
  1187.     *row_ptr = item_index % MultiListNumRows(mlw);
  1188.     *column_ptr = item_index / MultiListNumRows(mlw);
  1189.   }
  1190.   return (True);
  1191. }                /* End ItemToRowColumn */
  1192.  
  1193. /*===========================================================================*
  1194.  
  1195.                 E V E N T    A C T I O N    H A N D L E R S
  1196.  
  1197.  *===========================================================================*/
  1198.  
  1199. /*---------------------------------------------------------------------------*
  1200.  
  1201.     Set(mlw,event,params,num_params)
  1202.  
  1203.     This function sets a single text item in the MultiList.  Any previously
  1204.     selected items will be unselected, even if the user later aborts
  1205.     the click.  The item clicked on will be highlighted, and the
  1206.     MultiListMostRecentItem(mlw) variable will be set to the item clicked
  1207.     on if any, or -1 otherwise.
  1208.  
  1209.  *---------------------------------------------------------------------------*/
  1210.  
  1211. /* ARGSUSED */
  1212. static void
  1213. Set(mlw, event, params, num_params)
  1214.      XfwfMultiListWidget mlw;
  1215.      XEvent         *event;
  1216.      String         *params;
  1217.      Cardinal       *num_params;
  1218. {
  1219.   int             click_x,
  1220.                   click_y;
  1221.   int             status,
  1222.                   item_index,
  1223.                   row,
  1224.                   column;
  1225.  
  1226.   click_x = event->xbutton.x;
  1227.   click_y = event->xbutton.y;
  1228.   PixelToRowColumn(mlw, click_x, click_y, &row, &column);
  1229.   XfwfMultiListUnhighlightAll(mlw);
  1230.   status = RowColumnToItem(mlw, row, column, &item_index);
  1231.   if (status == False)
  1232.     item_index = -1;
  1233.   XfwfMultiListHighlightItem(mlw, item_index);
  1234.   MultiListMostRecentAct(mlw) = XfwfMultiListActionHighlight;
  1235.   MultiListMostRecentItem(mlw) = item_index;
  1236. }                /* End Set */
  1237.  
  1238.  
  1239. /*---------------------------------------------------------------------------*
  1240.  
  1241.     Unset(mlw,event,params,num_params)
  1242.  
  1243.     This function sets a single text item in the MultiList.  If the item
  1244.     is already unset, then nothing happens.  Otherwise, the item is
  1245.     unset and the selection array and selection count are updated.
  1246.  
  1247.  *---------------------------------------------------------------------------*/
  1248.  
  1249. /* ARGSUSED */
  1250. static void
  1251. Unset(mlw, event, params, num_params)
  1252.      XfwfMultiListWidget mlw;
  1253.      XEvent         *event;
  1254.      String         *params;
  1255.      Cardinal       *num_params;
  1256. {
  1257.   int             click_x,
  1258.                   click_y;
  1259.   int             status,
  1260.                   item_index,
  1261.                   row,
  1262.                   column;
  1263.  
  1264.   click_x = event->xbutton.x;
  1265.   click_y = event->xbutton.y;
  1266.   PixelToRowColumn(mlw, click_x, click_y, &row, &column);
  1267.   status = RowColumnToItem(mlw, row, column, &item_index);
  1268.   if (status == False)
  1269.     item_index = -1;
  1270.   XfwfMultiListUnhighlightItem(mlw, item_index);
  1271.   MultiListMostRecentAct(mlw) = XfwfMultiListActionUnhighlight;
  1272.   MultiListMostRecentItem(mlw) = item_index;
  1273. }                /* End Unset */
  1274.  
  1275.  
  1276. /*---------------------------------------------------------------------------*
  1277.  
  1278.     Toggle(mlw,event,params,num_params)
  1279.  
  1280.     This function toggles a text item in the MultiList, while leaving the
  1281.     other selections intact (up to the allowed number of selections).
  1282.     The item clicked on will be highlighted, and
  1283.     MultiListMostRecentItem(mlw) will be set to the item number clicked
  1284.     on, or -1 if no item was clicked on.
  1285.  
  1286.  *---------------------------------------------------------------------------*/
  1287.  
  1288. /* ARGSUSED */
  1289. static void
  1290. Toggle(mlw, event, params, num_params)
  1291.      XfwfMultiListWidget mlw;
  1292.      XEvent         *event;
  1293.      String         *params;
  1294.      Cardinal       *num_params;
  1295. {
  1296.   int             click_x,
  1297.                   click_y;
  1298.   int             status,
  1299.                   item_index,
  1300.                   row,
  1301.                   column;
  1302.  
  1303.   click_x = event->xbutton.x;
  1304.   click_y = event->xbutton.y;
  1305.   PixelToRowColumn(mlw, click_x, click_y, &row, &column);
  1306.   status = RowColumnToItem(mlw, row, column, &item_index);
  1307.   if (status == False)
  1308.     item_index = -1;
  1309.   MultiListMostRecentAct(mlw) = XfwfMultiListToggleItem(mlw, item_index);
  1310.   MultiListMostRecentItem(mlw) = item_index;
  1311. }                /* End Toggle */
  1312.  
  1313.  
  1314. /*---------------------------------------------------------------------------*
  1315.  
  1316.     Open(mlw,event,params,num_params)
  1317.  
  1318.     This routine handles the opening (normally double clicking)
  1319.     of an item.  All previous selections will be unselected, the
  1320.     clicked item will be selected, and the OPEN action will be recorded.
  1321.  
  1322.  *---------------------------------------------------------------------------*/
  1323.  
  1324. /* ARGSUSED */
  1325. static void
  1326. Open(mlw, event, params, num_params)
  1327.      XfwfMultiListWidget mlw;
  1328.      XEvent         *event;
  1329.      String         *params;
  1330.      Cardinal       *num_params;
  1331. {
  1332.   int             click_x,
  1333.                   click_y;
  1334.   int             status,
  1335.                   item_index,
  1336.                   row,
  1337.                   column;
  1338.  
  1339.   click_x = event->xbutton.x;
  1340.   click_y = event->xbutton.y;
  1341.   PixelToRowColumn(mlw, click_x, click_y, &row, &column);
  1342.   XfwfMultiListUnhighlightAll(mlw);
  1343.   status = RowColumnToItem(mlw, row, column, &item_index);
  1344.   if (status == False)
  1345.     item_index = -1;
  1346.   XfwfMultiListHighlightItem(mlw, item_index);
  1347.   MultiListMostRecentAct(mlw) = XfwfMultiListActionOpen;
  1348.   MultiListMostRecentItem(mlw) = item_index;
  1349. }                /* End Open */
  1350.  
  1351.  
  1352. /*---------------------------------------------------------------------------*
  1353.  
  1354.     OpenMany(mlw,event,params,num_params)
  1355.  
  1356.     This routine handles the opening (normally double clicking)
  1357.     of an item.  All previous selections will remain selected,
  1358.     which is why this routine is called OpenMany.  Many selections
  1359.     can be returned on an Open.  The clicked item will be selected,
  1360.     and the OPEN action will be recorded.
  1361.  
  1362.  *---------------------------------------------------------------------------*/
  1363.  
  1364. /* ARGSUSED */
  1365. static void
  1366. OpenMany(mlw, event, params, num_params)
  1367.      XfwfMultiListWidget mlw;
  1368.      XEvent         *event;
  1369.      String         *params;
  1370.      Cardinal       *num_params;
  1371. {
  1372.   int             click_x,
  1373.                   click_y;
  1374.   int             status,
  1375.                   item_index,
  1376.                   row,
  1377.                   column;
  1378.  
  1379.   click_x = event->xbutton.x;
  1380.   click_y = event->xbutton.y;
  1381.   PixelToRowColumn(mlw, click_x, click_y, &row, &column);
  1382.   status = RowColumnToItem(mlw, row, column, &item_index);
  1383.   if (status == False)
  1384.     item_index = -1;
  1385.   XfwfMultiListHighlightItem(mlw, item_index);
  1386.   MultiListMostRecentAct(mlw) = XfwfMultiListActionOpen;
  1387.   MultiListMostRecentItem(mlw) = item_index;
  1388. }                /* End OpenMany */
  1389.  
  1390.  
  1391. /*---------------------------------------------------------------------------*
  1392.  
  1393.     Notify(mlw,event,params,num_params)
  1394.  
  1395.     This function performs the Notify action, which is what happens
  1396.     when a user releases a button after clicking on an item.  If there
  1397.     was no item under the click, or if the item was insensitive, then
  1398.     Notify simply returns.  Otherwise, notify notifies the user via
  1399.     a callback of the current list of selected items.
  1400.  
  1401.     In addition, if the XtNpasteBuffer resource is true and a valid
  1402.     sensitive item was clicked on, the name of the last clicked on item
  1403.     will be placed in the X cut buffer (buf(0)).
  1404.  
  1405.  *---------------------------------------------------------------------------*/
  1406.  
  1407. /* ARGSUSED */
  1408. static void
  1409. Notify(mlw, event, params, num_params)
  1410.      XfwfMultiListWidget mlw;
  1411.      XEvent         *event;
  1412.      String         *params;
  1413.      Cardinal       *num_params;
  1414. {
  1415.   String          string;
  1416.   int             final_x,
  1417.                   final_y;
  1418.   Boolean         item_valid;
  1419.   int             item_index,
  1420.                   string_length,
  1421.                   row,
  1422.                   column;
  1423.   XfwfMultiListReturnStruct ret_value;
  1424.  
  1425.   final_x = event->xbutton.x;
  1426.   final_y = event->xbutton.y;
  1427.   PixelToRowColumn(mlw, final_x, final_y, &row, &column);
  1428.   item_valid = RowColumnToItem(mlw, row, column, &item_index);
  1429.   if (!item_valid || (item_index != MultiListMostRecentItem(mlw))) {
  1430.     if (MultiListMostRecentItem(mlw) != -1) {    /* Moved Away */
  1431.       XfwfMultiListUnhighlightItem(mlw,
  1432.                    MultiListMostRecentItem(mlw));
  1433.     }
  1434.     else {               /* Bad Click */
  1435.       XfwfMultiListUnhighlightAll(mlw);
  1436.       if (MultiListNotifyUnsets(mlw)) {
  1437.     ret_value.action =
  1438.       XfwfMultiListActionUnhighlight;
  1439.     ret_value.item = -1;
  1440.     ret_value.string = NULL;
  1441.     ret_value.num_selected =
  1442.       MultiListNumSelected(mlw);
  1443.     ret_value.selected_items =
  1444.       MultiListSelArray(mlw);
  1445.     XtCallCallbacks((Widget) mlw, XtNcallback,
  1446.             &ret_value);
  1447.       }
  1448.     }
  1449.     return;
  1450.   }
  1451.  
  1452.   string = MultiListItemString(MultiListNthItem(mlw, item_index));
  1453.   string_length = strlen(string);
  1454.   if (MultiListMostRecentAct(mlw) == XfwfMultiListActionHighlight) {
  1455.     if (MultiListPaste(mlw))
  1456.       XStoreBytes(XtDisplay(mlw), string, string_length);
  1457.   }
  1458.  
  1459.   if (((MultiListMostRecentAct(mlw) == XfwfMultiListActionHighlight) &&
  1460.        (MultiListNotifySets(mlw) == True)) ||
  1461.       ((MultiListMostRecentAct(mlw) == XfwfMultiListActionUnhighlight) &&
  1462.        (MultiListNotifyUnsets(mlw) == True)) ||
  1463.       ((MultiListMostRecentAct(mlw) == XfwfMultiListActionOpen) &&
  1464.        (MultiListNotifyOpens(mlw) == True))) {
  1465.     ret_value.action = MultiListMostRecentAct(mlw);
  1466.     ret_value.item = MultiListMostRecentItem(mlw);
  1467.     ret_value.string = string;
  1468.     ret_value.num_selected = MultiListNumSelected(mlw);
  1469.     ret_value.selected_items = MultiListSelArray(mlw);
  1470.     XtCallCallbacks((Widget) mlw, XtNcallback, (caddr_t) & ret_value);
  1471.   }
  1472. }                /* End Notify */
  1473.  
  1474. /*===========================================================================*
  1475.  
  1476.         U S E R    C A L L A B L E    U T I L I T Y    R O U T I N E S
  1477.  
  1478.  *===========================================================================*/
  1479.  
  1480. /*---------------------------------------------------------------------------*
  1481.  
  1482.     Boolean XfwfMultiListHighlightItem(mlw,item_index)
  1483.  
  1484.     This routine selects an item with index <item_index> in the
  1485.     MultiList widget <mlw>.  If a maximum number of selections is specified
  1486.     and exceeded, the earliest selection will be unselected.  If
  1487.     <item_index> doesn't correspond to an item the most recently
  1488.     clicked item will be set to -1 and this routine will immediately
  1489.     return, otherwise the most recently clicked item will be set to the
  1490.     current item.  If the clicked on item is not sensitive, or if the
  1491.     click is not on an item, False is returned, else True is returned.
  1492.  
  1493.  *---------------------------------------------------------------------------*/
  1494.  
  1495. Boolean
  1496. XfwfMultiListHighlightItem(mlw, item_index)
  1497.      XfwfMultiListWidget mlw;
  1498.      int             item_index;
  1499. {
  1500.   XfwfMultiListItem *item;
  1501.  
  1502.   if (MultiListMaxSelectable(mlw) == 0)
  1503.     return (False);;
  1504.   if (item_index < 0 || item_index >= MultiListNumItems(mlw)) {
  1505.     MultiListMostRecentItem(mlw) = -1;
  1506.     return (False);
  1507.   }
  1508.   item = MultiListNthItem(mlw, item_index);
  1509.   if (MultiListItemSensitive(item) == False) {
  1510.     XfwfMultiListUnhighlightAll(mlw);
  1511.     return (False);
  1512.   }
  1513.   MultiListMostRecentItem(mlw) = item_index;
  1514.   if (MultiListItemHighlighted(item) == True)
  1515.     return (True);
  1516.   if (MultiListNumSelected(mlw) == MultiListMaxSelectable(mlw)) {
  1517.     XfwfMultiListUnhighlightItem(mlw, MultiListSelArray(mlw)[0]);
  1518.   }
  1519.   MultiListItemHighlighted(item) = True;
  1520.   MultiListSelArray(mlw)[MultiListNumSelected(mlw)] = item_index;
  1521.   ++MultiListNumSelected(mlw);
  1522.   RedrawItem(mlw, item_index);
  1523.   return (True);
  1524. }                /* End XfwfMultiListHighlightItem */
  1525.  
  1526.  
  1527. /*---------------------------------------------------------------------------*
  1528.  
  1529.     XfwfMultiListHighlightAll(mlw)
  1530.  
  1531.     This routine highlights all highlightable items in the MultiList
  1532.     widget <mlw>, up to the maximum number of allowed highlightable
  1533.     items;
  1534.  
  1535.  *---------------------------------------------------------------------------*/
  1536.  
  1537. void
  1538. XfwfMultiListHighlightAll(mlw)
  1539.      XfwfMultiListWidget mlw;
  1540. {
  1541.   int             i;
  1542.   XfwfMultiListItem *item;
  1543.  
  1544.   MultiListNumSelected(mlw) = 0;
  1545.   for (i = 0; i < MultiListNumItems(mlw); i++) {
  1546.     item = MultiListNthItem(mlw, i);
  1547.     MultiListItemHighlighted(item) = True;
  1548.   }
  1549.   for (i = 0; i < MultiListNumItems(mlw); i++) {
  1550.     if (MultiListNumSelected(mlw) == MultiListMaxSelectable(mlw))
  1551.       break;
  1552.     item = MultiListNthItem(mlw, i);
  1553.     MultiListItemHighlighted(item) = True;
  1554.     MultiListSelArray(mlw)[MultiListNumSelected(mlw)] = i;
  1555.     ++MultiListNumSelected(mlw);
  1556.   }
  1557.   RedrawAll(mlw);
  1558. }                /* End XfwfMultiListHighlightAll */
  1559.  
  1560.  
  1561. /*---------------------------------------------------------------------------*
  1562.  
  1563.     XfwfMultiListUnhighlightItem(mlw,item_index)
  1564.  
  1565.     This routine unselects the item with index <item_index> in the
  1566.     MultiList widget <mlw>.  If <item_index> doesn't correspond to a
  1567.     selected item, then nothing will happen.  Otherwise, the item
  1568.     is unselected and the selection array and count are updated.
  1569.  
  1570.  *---------------------------------------------------------------------------*/
  1571.  
  1572. void
  1573. XfwfMultiListUnhighlightItem(mlw, item_index)
  1574.      XfwfMultiListWidget mlw;
  1575.      int             item_index;
  1576. {
  1577.   int             i;
  1578.   XfwfMultiListItem *item;
  1579.  
  1580.   if (MultiListMaxSelectable(mlw) == 0)
  1581.     return;
  1582.   if (item_index < 0 || item_index >= MultiListNumItems(mlw))
  1583.     return;
  1584.   item = MultiListNthItem(mlw, item_index);
  1585.   if (MultiListItemHighlighted(item) == False)
  1586.     return;
  1587.   MultiListItemHighlighted(item) = False;
  1588.  
  1589.   for (i = 0; i < MultiListNumSelected(mlw); i++)
  1590.     if (MultiListSelArray(mlw)[i] == item_index)
  1591.       break;
  1592.   for (i = i + 1; i < MultiListNumSelected(mlw); i++)
  1593.     MultiListSelArray(mlw)[i - 1] = MultiListSelArray(mlw)[i];
  1594.   --MultiListNumSelected(mlw);
  1595.  
  1596.   RedrawItem(mlw, item_index);
  1597. }                /* End XfwfMultiListUnhighlightItem */
  1598.  
  1599.  
  1600. /*---------------------------------------------------------------------------*
  1601.  
  1602.     XfwfMultiListUnhighlightAll(mlw)
  1603.  
  1604.     This routine unhighlights all items in the MultiList widget <mlw>.
  1605.  
  1606.  *---------------------------------------------------------------------------*/
  1607.  
  1608. void
  1609. XfwfMultiListUnhighlightAll(mlw)
  1610.      XfwfMultiListWidget mlw;
  1611. {
  1612.   int             i;
  1613.   XfwfMultiListItem *item;
  1614.  
  1615.   for (i = 0; i < MultiListNumItems(mlw); i++) {
  1616.     item = MultiListNthItem(mlw, i);
  1617.     if (MultiListItemHighlighted(item))
  1618.       XfwfMultiListUnhighlightItem(mlw, i);
  1619.   }
  1620.   MultiListNumSelected(mlw) = 0;
  1621. }                /* End XfwfMultiListUnhighlightAll */
  1622.  
  1623.  
  1624. /*---------------------------------------------------------------------------*
  1625.  
  1626.     int XfwfMultiListToggleItem(mlw,item_index)
  1627.  
  1628.     This routine highlights the item with index <item_index>
  1629.     if it is unhighlighted and unhighlights it if it is already
  1630.     highlighted.  The action performed by the toggle is returned
  1631.     (XfwfMultiListActionHighlight or XfwfMultiListActionUnhighlight).
  1632.  
  1633.  *---------------------------------------------------------------------------*/
  1634.  
  1635. int
  1636. XfwfMultiListToggleItem(mlw, item_index)
  1637.      XfwfMultiListWidget mlw;
  1638.      int             item_index;
  1639. {
  1640.   XfwfMultiListItem *item;
  1641.  
  1642.   if (MultiListMaxSelectable(mlw) == 0)
  1643.     return (XfwfMultiListActionNothing);
  1644.   if (item_index < 0 || item_index >= MultiListNumItems(mlw))
  1645.     return (XfwfMultiListActionNothing);
  1646.   item = MultiListNthItem(mlw, item_index);
  1647.   if (MultiListItemHighlighted(item)) {
  1648.     XfwfMultiListUnhighlightItem(mlw, item_index);
  1649.     return (XfwfMultiListActionUnhighlight);
  1650.   }
  1651.   else {
  1652.     XfwfMultiListHighlightItem(mlw, item_index);
  1653.     return (XfwfMultiListActionHighlight);
  1654.   }
  1655. }                /* End XfwfMultiListToggleItem */
  1656.  
  1657.  
  1658. /*---------------------------------------------------------------------------*
  1659.  
  1660.     XfwfMultiListReturnStruct *XfwfMultiListGetHighlighted(mlw)
  1661.  
  1662.     This routine takes a MultiList widget <mlw> and returns a
  1663.     XfwfMultiListReturnStruct whose num_selected and selected_items
  1664.     fields contain the highlight information.  The action field
  1665.     is set to MULTILIST_ACTION_STATUS, and the item_index and string
  1666.     fields are invalid.
  1667.  
  1668.  *---------------------------------------------------------------------------*/
  1669.  
  1670. XfwfMultiListReturnStruct *
  1671. XfwfMultiListGetHighlighted(mlw)
  1672.      XfwfMultiListWidget mlw;
  1673. {
  1674.   XfwfMultiListItem *item;
  1675.   static XfwfMultiListReturnStruct ret_value;
  1676.  
  1677.   ret_value.action = XfwfMultiListActionOpen;
  1678.   if (MultiListNumSelected(mlw) == 0) {
  1679.     ret_value.item = -1;
  1680.     ret_value.string = NULL;
  1681.   }
  1682.   else {
  1683.     ret_value.item = MultiListSelArray(mlw)
  1684.       [MultiListNumSelected(mlw) - 1];
  1685.     item = MultiListNthItem(mlw, ret_value.item);
  1686.     ret_value.string = MultiListItemString(item);
  1687.   }
  1688.   ret_value.num_selected = MultiListNumSelected(mlw);
  1689.   ret_value.selected_items = MultiListSelArray(mlw);
  1690.   return (&ret_value);
  1691. }                /* End XfwfMultiListGetHighlighted */
  1692.  
  1693.  
  1694. /*---------------------------------------------------------------------------*
  1695.  
  1696.     Boolean XfwfMultiListIsHighlighted(mlw,item_index)
  1697.  
  1698.     This routine checks if the item with index <item_index>
  1699.     is highlighted and returns True or False depending.  If
  1700.     <item_index> is invalid, False is returned.
  1701.  
  1702.  *---------------------------------------------------------------------------*/
  1703.  
  1704. Boolean
  1705. XfwfMultiListIsHighlighted(mlw, item_index)
  1706.      XfwfMultiListWidget mlw;
  1707.      int             item_index;
  1708. {
  1709.   XfwfMultiListItem *item;
  1710.  
  1711.   if (item_index < 0 || item_index >= MultiListNumItems(mlw))
  1712.     return (False);
  1713.   item = MultiListNthItem(mlw, item_index);
  1714.   return (MultiListItemHighlighted(item));
  1715. }                /* End XfwfMultiListIsHighlighted */
  1716.  
  1717.  
  1718. /*---------------------------------------------------------------------------*
  1719.  
  1720.     Boolean XfwfMultiListGetItemInfo(mlw,item_index,str_ptr,h_ptr,s_ptr)
  1721.  
  1722.     This routine returns the string, highlight status and
  1723.     sensitivity information for the item with index <item_index>
  1724.     via the pointers <str_ptr>, <h_ptr> and <s_ptr>.  If the item
  1725.     index is invalid, False is returned, else True is returned.
  1726.  
  1727.  *---------------------------------------------------------------------------*/
  1728.  
  1729. Boolean
  1730. XfwfMultiListGetItemInfo(mlw, item_index, str_ptr, h_ptr, s_ptr)
  1731.      XfwfMultiListWidget mlw;
  1732.      int             item_index;
  1733.      String         *str_ptr;
  1734.      Boolean        *h_ptr,
  1735.                     *s_ptr;
  1736. {
  1737.   XfwfMultiListItem *item;
  1738.  
  1739.   if (item_index < 0 || item_index >= MultiListNumItems(mlw))
  1740.     return (False);
  1741.   item = MultiListNthItem(mlw, item_index);
  1742.   *str_ptr = MultiListItemString(item);
  1743.   *h_ptr = MultiListItemHighlighted(item);
  1744.   *s_ptr = MultiListItemSensitive(item);
  1745.   return (True);
  1746. }                /* End XfwfMultiListGetItemInfo */
  1747.  
  1748.  
  1749. /*---------------------------------------------------------------------------*
  1750.  
  1751.     XfwfMultiListSetNewData(mlw,list,nitems,longest,resize,
  1752.         sensitivity_array)
  1753.  
  1754.     This routine will set a new set of strings <list> into the
  1755.     MultiList widget <mlw>.  If <resize> is True, the MultiList widget will
  1756.     try to resize itself.
  1757.  
  1758.  *---------------------------------------------------------------------------*/
  1759.  
  1760. void
  1761. XfwfMultiListSetNewData(mlw, list, nitems, longest, resize, sensitivity_array)
  1762.      XfwfMultiListWidget mlw;
  1763.      String         *list;
  1764.      int             nitems,
  1765.                      longest;
  1766.      int             resize;
  1767.      Boolean        *sensitivity_array;
  1768. {
  1769.   DestroyOldData(mlw);
  1770.   MultiListList(mlw) = list;
  1771.   MultiListNumItems(mlw) = max(nitems, 0);
  1772.   MultiListLongest(mlw) = max(longest, 0);
  1773.   MultiListSensitiveArray(mlw) = sensitivity_array;
  1774.   InitializeNewData(mlw);
  1775.   RecalcCoords(mlw, resize, resize);
  1776.   if (XtIsRealized((Widget) mlw))
  1777.     Redisplay(mlw, NULL, NULL);
  1778. }                /* End XfwfMultiListSetNewData */
  1779.